home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / lists / mint / l_0799 / 574 < prev    next >
Encoding:
Internet Message Format  |  1994-08-27  |  7.3 KB
  1. Subject: Re: i/o speed (was: pipes & ptys)
  2. Date: Fri, 22 Oct 93 23:07:36 CET
  3. From: Juergen Lock <nox@jelal.north.de>
  4. In-Reply-To: <9310221236.AA17935@dohle.techfak.uni-bielefeld.de>; from "itschere@TechFak.Uni-Bielefeld.DE" at Oct 22, 93 1:36 pm
  5. Message-Id: <9310222207.AA00138@jelal.north.de>
  6.  
  7. itschere@TechFak.Uni-Bielefeld.DE writes:
  8. > Juergen Lock
  9. > 
  10. > > > Ok, got this, but: (see my other mail) it will return as soon as ther is
  11. > > > some data, say, when it get's its next time slice, which is 16ms long on
  12. > > > my 60Hz TT-VBL, right? Now I estimate that the writer (if really using 1
  13. > > > bytes I/O), doesn't manage to output more than something like 30 chars per
  14. > > > timeslice, so 60 slices a 30 bytes (always completely ignoring the time
  15. > > > I need to read the data),~
  16. > >
  17. > >  this is the time we're trying to improve...
  18. > 
  19. > feel free to do so... :-)
  20. > 
  21. > > > makes 1800 CPS, and that looks like the number I've measured.
  22. > >
  23. > >  how much cps does the writer get when you send it to /dev/null
  24. > > instead?  the difference between that and your 1800 is the only thing
  25. > > we can improve here of course... for more the writing program has to
  26. > > use longer writes.
  27. > 
  28. > naturally more, don't know exactly, but sure not 10 times as much... :-(
  29. > 
  30. > to summarize it:
  31. > 
  32. > if a program chooses to output one char, say, through a piped pseudo
  33. > terminal, it looks more or less like this:
  34. > 
  35. > Cconout('!') ->
  36. > Fwrite(?, 1, "!") ->
  37. > tty_write(...) ->
  38. > tty_putchar() ->
  39. > pipe_write().
  40.  
  41.  (actually Cconout doesn't go thru Fwrite but its still slow.)
  42. > 
  43. > and the reader get's:
  44. > 
  45. > Fread() ->
  46. > tty_read() ->
  47. > tty_getchar() ->
  48. > pipe_read().
  49.  
  50.  ...only the reader can be improved.
  51.  
  52.  Fread() ->
  53.  tty_read() ->
  54.  one pty_bread().
  55. > 
  56. > and in the meantime, half an hour is gone... ;-(
  57. > 
  58. > > > If a) you really use big chunks and b) modems are operated by interrupt...
  59. > > 
  60. > >  yup!  actually modems are operated by interrupts already, only
  61. > > the buffer status is still polled and data is read/written
  62. > > one-byte-at-a-time...
  63. > 
  64. > to be more accurate, only incoming bytes raise an interrupt, but for outgoing
  65. > the i/o chip is polled to see if it's ready. perhaps not immediately after the
  66. > byte was send away, but before a char is to be send.
  67.  
  68.  thats true for the midi port and keyboard controller but...
  69.  
  70. >  at least the MFP does also
  71. > support an interrupt for "output-buffer-empty", the newer chips also, I think.
  72.  
  73.  (any serial port chip has that :)
  74.  
  75. > but as far as I know, these are not used so far.
  76.  
  77.  ...but the modem port(s) do use send buffers.  not that ataris BIOS
  78. modem drivers are known to be fast and bug-free but they do use the rx
  79. and tx interrupts...
  80. > 
  81. > by using these and a new buffer managing, completely obsoleting the bios,
  82. > you'll gain lots of speed, I presume... :-)
  83.  
  84.  yup.  and if the device can get around all the char <-> long `conversions'
  85. etc so that a Fwrite can end up as just a few movem.l (bcopy...) you get
  86. even more speed.  this is the write() replacement i have in uucp:
  87.  
  88. #if MINT_FASTWRITE
  89. /* here is fastwrite()...  comments like on fastread() apply. */
  90. int fastwrite (fd, buf, cwrite, qs)
  91. int fd;
  92. char *buf;
  93. unsigned cwrite;
  94. struct ssysdep_serial_port *qs;
  95. {
  96.   char *p = buf;
  97.   int slept = 0;
  98.  
  99.   /* /dev/midi doesn't have a write buffer :-( */
  100.   if (!S_iorec || S_biosdev == 3)
  101.     return write (fd, buf, cwrite);
  102.  
  103.   /* if we should watch CD and its not there flush buffers and return 0. */
  104.   if (buf && S_fwatchcd && !pollcd (S_biosdev)) {
  105. #if MINT_FASTREAD
  106.     (void) fastread (fd, (char *) NULL, 0, qs);
  107. #endif
  108.     buf = (char *) NULL;
  109.   }
  110.  
  111.   if (!buf) {
  112.     long stack = Super (0L);
  113.  
  114.     /* flush send buffer...  should be safe to just set the tail pointer. */
  115.     S_iorec[1].ibuftl = S_iorec[1].ibufhd;
  116.     (void) Super (stack);
  117.     return 0;
  118.   }
  119.  
  120.   if (!cwrite)
  121.     /* nothing to do... */
  122.     return 0;
  123.  
  124.   do {
  125.     char ch;
  126.     unsigned short tail, bsize, wrap, newtail;
  127.     long free, stack;
  128.  
  129.     /* enter supervisor mode... */
  130.     stack = Super (0L);
  131.  
  132.     tail = S_iorec[1].ibuftl;
  133.     bsize = S_iorec[1].ibufsiz;
  134.     if ((free = S_iorec[1].ibufhd - tail - 1) < 0)
  135.       free += bsize;
  136.  
  137.     /* if buffer is full or we're blocking and can't write enuf */
  138.     if (!free || (qs->fread_blocking && free < cwrite && free < bsize/2)) {
  139.       long sleepchars;
  140.       unsigned isleep;
  141.  
  142.       /* leave super mode. */
  143.       (void) Super (stack);
  144.  
  145.       /* if the write should not block thats it. */
  146.       if (!qs->fread_blocking)
  147.     return p - buf;
  148.  
  149.       /* else sleep the (minimum) time it takes until the buffer is
  150.      either half-empty or has space enough for the write, wichever
  151.      is smaller. */
  152.       if ((sleepchars = bsize/2) > cwrite)
  153.     sleepchars = cwrite;
  154.       sleepchars -= free;
  155.  
  156.       isleep = (unsigned) ((sleepchars * 10000L) / qs->ibaud);
  157.  
  158.       /* except that if we already slept and the buffer still was full we
  159.      sleep for at least 20 milliseconds. (driver must be waiting for
  160.      some handshake signal and we don't want to hog the processor.) */
  161.       if (slept && isleep < 20)
  162.     isleep = 20;
  163.  
  164.       if (isleep < 5)
  165.     /* if it still would be less than 5 milliseconds then just
  166.        give up this timeslice */
  167.     (void) Syield();
  168.       else
  169.     usleep ((unsigned long) isleep * 1000);
  170.  
  171.       /* loop and try again. */
  172.       slept = !free;
  173.       continue;
  174.     }
  175.     slept = 0;
  176.  
  177.     /* save the 1st char, we could need it later. */
  178.     ch = *p;
  179.     wrap = bsize - tail;
  180.     if (free > cwrite)
  181.       free = cwrite;
  182.     cwrite -= free;
  183.  
  184.     /* now copy to buffer.  if its just a few then do it here... */
  185.     if (free < 5) {
  186.       char *q = S_iorec[1].ibuf + tail;
  187.  
  188.       while (free--) {
  189.     if (!--wrap)
  190.       q -= bsize;
  191.     *++q = *p++;
  192.       }
  193.       newtail = q - S_iorec[1].ibuf;
  194.  
  195.     /* ...else use bcopy. */
  196.     } else {
  197.       /* --wrap and tail+1 because tail is `inc before access' */
  198.       if (--wrap < free) {
  199.     bcopy (p, S_iorec[1].ibuf + tail + 1, wrap);
  200.     bcopy (p + wrap, S_iorec[1].ibuf, free - wrap);
  201.     newtail = free - wrap - 1;
  202.       } else {
  203.     bcopy (p, S_iorec[1].ibuf + tail + 1, free);
  204.     newtail = tail + free;
  205.       }
  206.       p += free;
  207.     }
  208.  
  209.     /* the following has to be done with interrupts off to avoid
  210.        race conditions. */
  211.     {
  212.       short sr = intsoff ();
  213.  
  214.       /* if the buffer is empty there might be no interrupt that sends
  215.      the next char, so we send it thru the xcon* vector. */
  216.       if (S_iorec[1].ibufhd == S_iorec[1].ibuftl) {
  217.     (void) xcon_exec (S_bioswrite, (unsigned char) ch);
  218.  
  219.     /* if the buffer now is still empty we must set the head pointer
  220.        to skip the 1st char (that we just sent). */
  221.     if (S_iorec[1].ibufhd == S_iorec[1].ibuftl) {
  222.       if (++tail >= bsize)
  223.         tail = 0;
  224.       S_iorec[1].ibufhd = tail;
  225.     }
  226.       }
  227.       S_iorec[1].ibuftl = newtail;
  228.  
  229.       intson (sr);
  230.     }
  231.     (void) Super (stack);
  232.  
  233.   /* if we may block loop until everything is written */
  234.   } while (cwrite && qs->fread_blocking);
  235.  
  236.   return p - buf;
  237. }
  238. #endif /* MINT_FASTWRITE */
  239. #endif /* __MINT__ */
  240.  
  241.  when this is constantly sending ~2000 cps on modem2 the process
  242. (uucico) takes 4 or 5 % CPU according to `top'.  (megaSTe, uucp-g with
  243. 1K packets and window 7.  receiving takes more.)
  244.  
  245.  maybe people understand better now why i call unnecessary char <-> long
  246. shuffling overhead... :-)
  247.  
  248.  cheers
  249.     Juergen
  250. -- 
  251. J"urgen Lock / nox@jelal.north.de / UUCP: ..!uunet!unido!uniol!jelal!nox
  252.                                 ...ohne Gewehr
  253. PGP public key fingerprint =  8A 18 58 54 03 7B FC 12  1F 8B 63 C7 19 27 CF DA 
  254.